﻿using System;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;

namespace VietKinsNutrition.Common
{
    public class Util
    {
        #region ATTRIBUTE
        public const byte NULL_BYTE = byte.MinValue;
        public const short NULL_SHORT = short.MinValue;
        public const int NULL_INT = int.MinValue;
        public const long NULL_LONG = long.MinValue;
        public const decimal NULL_DECIMAL = decimal.MinValue;
        public const float NULL_FLOAT = float.NaN;
        public const double NULL_DOUBLE = double.NaN;
        public const Single NULL_SINGLE = Single.NaN;
        public static DateTime NULL_DATETIME = DateTime.MinValue;
        public static Guid NULL_GUID = Guid.Empty;
        public static string NULL_STRING = string.Empty;
        public static string KEY_ENCRYPT_VALUE = "HAIMINH";
        #endregion

        #region CONSTRUCTOR
        static Util() { }
        #endregion

        #region NULL OBJECT METHODS
        /// <summary>
        /// Trả về giá trị được coi là null của objectToGet (nếu thuộc kiểu không null như int, float thì trả về MinValue)
        /// </summary>
        public static object GetNullOf(object objectToGet)
        {
            if (objectToGet == null) return null;
            if (objectToGet == DBNull.Value) return objectToGet;
            if (objectToGet is DBNull) return DBNull.Value;
            if (objectToGet is bool) return false;
            if (objectToGet is short) return short.MinValue;
            if (objectToGet is int) return int.MinValue;
            if (objectToGet is long) return long.MinValue;
            if (objectToGet is decimal) return decimal.MinValue;
            if (objectToGet is DateTime) return DateTime.MinValue;
            if (objectToGet is double) return double.NaN;
            if (objectToGet is float) return float.NaN;
            if (objectToGet is Single) return Single.NaN;
            if (objectToGet is string) return string.Empty;
            if (objectToGet is Guid) return Guid.Empty;
            return null;
        }

        /// <summary>
        /// Kiểm tra xem obj có phải null không (nếu thuộc kiểu không null như int, float thì kiểm tra xem có phải MinValue không)
        /// </summary>
        public static bool IsNull(object obj)
        {
            if (obj != null) return obj.Equals(Util.GetNullOf(obj));
            return true;
        }

        /// <summary>
        /// Kiểm tra xem objectToSet có phải null không, nếu null thì gán giá trị value cho nó (nếu thuộc kiểu không null như int, float thì kiểm tra xem có phải MinValue không)
        /// </summary>
        public static object ReplaceNullTo(object objectToSet, object value)
        {
            object o = objectToSet;
            if (Util.IsNull(objectToSet)) return value;
            return o;
        }

        /// <param name="isExactlyNull">Nếu để là true thì chỉ kiểm tra objectToSet có là null không nếu thuộc kiểu không null như int, float sẽ không kiểm tra</param>
        public static object ReplaceNullTo(object objectToSet, object value, bool isExactlyNull)
        {
            if ((isExactlyNull) && (objectToSet == null)) objectToSet = value;
            else if (Util.IsNull(objectToSet)) objectToSet = value;
            return objectToSet;
        }

        public static void SetToNull(ref object objectToSet)
        {
            objectToSet = Util.GetNullOf(objectToSet);
        }

        /// <summary>
        /// Kiểm tra xem obj có phải là giá trị DBNull hoặc null không
        /// </summary>
        public static bool IsDBNull(object obj)
        {
            if (obj != null) return (obj == DBNull.Value);
            return false;
        }

        /// <summary>
        /// Kiểm tra xem objectToSet có phải DBNull không, nếu null thì gán giá trị value cho nó
        /// </summary>
        public static object ReplaceDBNullTo(object objectToSet, object value)
        {
            object o = objectToSet;
            if (Util.IsDBNull(objectToSet)) o = value;
            return o;
        }
        #endregion

        #region SPELL NUMBER

        public static string docso(string s)
        {
            string output = "";
            if (s != "")
            {
                s = xoasokhong(s);
                switch (s.Length)
                {
                    case 1: output = motso(s) + " đồng"; break;
                    case 2: output = haiso(s) + " đồng"; break;
                    case 3: output = baso(s) + " đồng"; break;
                    default: output = nhieuso(s, s.Length); break;
                }
            }

            return output;
        }

        //public static void docso(TextBox txtTextBox, Label lblLabel)
        //{
        //    string s = txtTextBox.Text.Trim();
        //    if (s != "")
        //    {
        //        s = xoasokhong(s);
        //        switch (s.Length)
        //        {
        //            case 1: lblLabel.Text = motso(s) + " đồng"; break;
        //            case 2: lblLabel.Text = haiso(s) + " đồng"; break;
        //            case 3: lblLabel.Text = baso(s) + " đồng"; break;
        //            default: lblLabel.Text = nhieuso(s, s.Length); break;
        //        }
        //    }
        //    else lblLabel.Text = "Bạn phải nhập giá trị vào";
        //}

        #region Number function
        private static string motso(string bienso)
        {
            switch (bienso)
            {
                case "0": return "không";
                case "1": return "một";
                case "2": return "hai";
                case "3": return "ba";
                case "4": return "bốn";
                case "5": return "năm";
                case "6": return "sáu";
                case "7": return "bảy";
                case "8": return "tám";
                case "9": return "chín";
            }
            return "không";
        }
        private static string haiso(string bienso)
        {
            string biendoc = " mười ";
            if ((bienso.Substring(1, 1) == "0") && (bienso.Substring(0, 1) != "1")) biendoc = motso(bienso.Substring(0, 1)) + " mươi ";
            if (bienso.Substring(1, 1) != "0")
                switch (bienso.Substring(1, 1))
                {
                    case "5":
                        if (bienso.Substring(0, 1) == "1") biendoc = " mười lăm";
                        else biendoc = motso(bienso.Substring(0, 1)) + " mươi lăm";
                        break;
                    case "1":
                        if (bienso.Substring(0, 1) == "1") biendoc = " mười một";
                        else biendoc = motso(bienso.Substring(0, 1)) + " mươi mốt";
                        break;
                    default:
                        if (bienso.Substring(0, 1) == "1") biendoc = " mười " + motso(bienso.Substring(1, 1));
                        else biendoc = motso(bienso.Substring(0, 1)) + " mươi " + motso(bienso.Substring(1, 1));
                        break;
                }

            return biendoc;
        }
        private static string baso(string bienso)
        {
            string biendoc = "trăm";
            if (bienso.Substring(1, 1) == "0")
            {
                if (bienso.Substring(2, 1) == "0") biendoc = motso(bienso.Substring(0, 1)) + " trăm ";
                else biendoc = motso(bienso.Substring(0, 1)) + " trăm lẻ " + motso(bienso.Substring(2, 1));
            }
            else
            {
                biendoc = motso(bienso.Substring(0, 1)) + " trăm " + haiso(bienso.Substring(1, 2));
            }
            return biendoc;
        }
        #endregion

        // Process 0 number
        private static string xoasokhong(string tam)
        {
            while (tam[0] == '0')
            {
                if (tam.Length > 1) tam = tam.Substring(1, tam.Length - 1);
                else break;
            }
            return tam;
        }
        // Insert value
        private static string kieuchen(int tam)
        {
            switch (tam)
            {
                case 0: return " đồng ";
                case 1: return " nghìn ";
                case 2: return " triệu ";
                case 3: return " tỷ ";
            }
            return "";
        }
        // Read multi number
        private static string nhieuso(string bienso, int dodai)
        {
            string biendoc = "", bientam = "";
            int i = 0;
            while ((dodai) > 3)
            {

                bientam = baso(bienso.Substring(bienso.Length - 3, 3));
                bienso = bienso.Substring(0, bienso.Length - 3);
                biendoc = bientam + kieuchen(i) + biendoc;
                i++;
                if (i > 3) i = 1;
                if (dodai > 3) dodai = dodai - 3;
            }
            if (dodai == 1) biendoc = motso(bienso) + kieuchen(i) + biendoc;
            if (dodai == 2) biendoc = haiso(bienso) + kieuchen(i) + biendoc;
            if (dodai == 3) biendoc = baso(bienso) + kieuchen(i) + biendoc;
            return biendoc;
        }

        #endregion

        #region STRING METHODS
        /// <summary>
        /// Cắt lấy một đoạn trong chuỗi theo các giá trị truyền vào, nếu null hoặc giá trị để cắt không phù hợp sẽ trả về giá trị chuỗi rỗng
        /// </summary>
        public static string CutString(string source, int start, int length)
        {
            if ((source == null) || (source.Length < start)) return "";
            if ((source.Length > start) && (source.Length - start < length)) return source.Substring(start);
            return source.Substring(start, length);
        }

        public static string CutString(string source, int start, int end, string appendedText)
        {
            return Util.CutString(source, start, end - start + 1) + appendedText;
        }

        /// <summary>
        /// Cắt một chuỗi theo số từ cho trước
        /// </summary>
        public static string CutStringByWord(string source, int wordLength)
        {
            return Util.CutStringByWord(source, wordLength, null);
        }

        public static string CutStringByWord(string source, int wordLength, string appendedText)
        {
            if (source == null) return "";
            string appended = appendedText == null ? "" : appendedText;
            MatchCollection mc = Regex.Matches(source, @"\w*");

            int i = 0;
            foreach (Match m in mc)
            {
                i += 1;
                if (i == wordLength) return Util.CutString(source, 0, m.Index + m.Value.Length) + appended;
            }
            return source + appended;
        }

        /// <summary>
        /// Kiểm tra xem chuỗi truyền vào có phải là 1 số hay không
        /// </summary>
        public static bool IsNumber(string source)
        {
            if (!string.IsNullOrEmpty(source))
            {
                if (source.IndexOf("-") == 0) source.Remove(0, 1);

                char[] cs = source.ToCharArray();
                foreach (char c in cs)
                {
                    if (!char.IsDigit(c)) return false;
                }
                return true;
            }
            return false;
        }

        /// <summary>
        /// Kiểm tra một chuỗi xem có phải là số nguyên hoặc số thập phân hay không (có thể định nghĩa dấu thập phân)
        /// </summary>
        public static bool IsDecimalNumber(string source)
        {
            if (!string.IsNullOrEmpty(source))
            {
                if (source.IndexOf("-") == 0) source.Remove(0, 1);
                if (source.IndexOf(".") > 0) source.Remove(source.IndexOf("."), 1);

                char[] cs = source.ToCharArray();
                foreach (char c in cs)
                {
                    if (!char.IsDigit(c)) return false;
                }
                return true;
            }
            return false;
        }

        public static bool IsDecimalNumber(string source, string decimalPoint)
        {
            if (!string.IsNullOrEmpty(source))
            {
                if (source.IndexOf("-") == 0) source.Remove(0, 1);
                if (source.IndexOf(decimalPoint) != 0) source.Remove(source.IndexOf(decimalPoint), decimalPoint.Length);

                char[] cs = source.ToCharArray();
                foreach (char c in cs)
                {
                    if (!char.IsDigit(c)) return false;
                }
                return true;
            }
            return false;
        }

        /// <summary>
        /// Chuyển một chuỗi thành kiểu số nguyên int sau khi đã kiểm tra
        /// </summary>
        public static int ToInteger(string source)
        {
            if (Util.IsNumber(source))
            {
                try
                {
                    return int.Parse(source);
                }
                catch { }
            }
            return int.MinValue;
        }

        /// <summary>
        /// Chuyển một số thành kiểu số nguyên long sau khi đã kiểm tra
        /// </summary>
        public static long ToLong(string source)
        {
            if (Util.IsNumber(source))
            {
                try
                {
                    return long.Parse(source);
                }
                catch { }
            }
            return long.MinValue;
        }

        /// <summary>
        /// Chuyển một chuổi thành kiểu số cho trước sau khi đã kiểm tra
        /// </summary>
        public static object ToNumber(string source, string numberType)
        {
            if (Util.IsDecimalNumber(source))
            {
                try
                {
                    switch (numberType.ToLower())
                    {
                        case "byte":
                            return Convert.ToByte(source);

                        case "sbyte":
                            return Convert.ToSByte(source);

                        case "short":
                        case "int16":
                            return Convert.ToInt16(source);

                        case "ushort":
                        case "uint16":
                            return Convert.ToUInt16(source);

                        case "int":
                        case "int32":
                            return Convert.ToInt32(source);

                        case "uint":
                        case "uint32":
                            return Convert.ToUInt32(source);

                        case "long":
                        case "int64":
                            return Convert.ToInt64(source);

                        case "ulong":
                        case "uint64":
                            return Convert.ToUInt64(source);

                        case "decimal":
                            return Convert.ToDecimal(source);

                        case "double":
                            return Convert.ToDouble(source);

                        case "Single":
                            return Convert.ToSingle(source);
                    }
                }
                catch { }
            }
            return null;
        }

        public static object ToNumber(string source, Type numberType)
        {
            return Util.ToNumber(source, numberType.Name);
        }

        public static object ToNumber(string source, Type numberType, string decimalPoint)
        {
            if (Util.IsDecimalNumber(source, decimalPoint))
            {
                if (source.IndexOf(decimalPoint) != 0) source.Replace(decimalPoint, ".");

                return Util.ToNumber(source, numberType);
            }
            return null;
        }
        #endregion

        #region SECURITY METHODS
        /// <summary>
        /// Mã hóa theo thuật toán MD5 (1 chuỗi hoặc một mảng byte)
        /// </summary>
        public static string MD5Encrypt(string source)
        {
            if (Util.IsNull(source)) return "";

            byte[] clearBytes = Encoding.Unicode.GetBytes(source);
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] hashBytes = md5.ComputeHash(clearBytes);

            return BitConverter.ToString(hashBytes);
        }

        //public static byte[] MD5Encrypt(byte[] source)
        //{
        //    if (Util.IsNull(source)) return null;
        //    MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
        //    byte[] hashBytes = md5.ComputeHash(source);
        //    return hashBytes;
        //}

        public static string MD5Encrypt(string toEncrypt, bool useHashing)
        {
            byte[] keyArray;
            byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);

            if (useHashing)
            {
                MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
                keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(KEY_ENCRYPT_VALUE));
            }
            else
                keyArray = UTF8Encoding.UTF8.GetBytes(KEY_ENCRYPT_VALUE);

            TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
            tdes.Key = keyArray;
            tdes.Mode = CipherMode.ECB;
            tdes.Padding = PaddingMode.PKCS7;

            ICryptoTransform cTransform = tdes.CreateEncryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }
        public static string MD5Decrypt(string toDecrypt, bool useHashing)
        {
            byte[] keyArray;
            byte[] toEncryptArray = Convert.FromBase64String(toDecrypt);

            if (useHashing)
            {
                MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
                keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(KEY_ENCRYPT_VALUE));
            }
            else
                keyArray = UTF8Encoding.UTF8.GetBytes(KEY_ENCRYPT_VALUE);

            TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
            tdes.Key = keyArray;
            tdes.Mode = CipherMode.ECB;
            tdes.Padding = PaddingMode.PKCS7;

            ICryptoTransform cTransform = tdes.CreateDecryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return UTF8Encoding.UTF8.GetString(resultArray);
        }
        /// <summary>
        /// Mã hóa theo thuật toán SHA1 (1 chuỗi hoặc một mảng byte)
        /// </summary>
        public static string SHA1Encrypt(string source)
        {
            if (Util.IsNull(source)) return "";

            byte[] clearBytes = Encoding.Unicode.GetBytes(source);
            SHA1Managed sha1 = new SHA1Managed();
            byte[] hashBytes = sha1.ComputeHash(clearBytes);

            return BitConverter.ToString(hashBytes);
        }

        public static byte[] SHA1Encrypt(byte[] source)
        {
            if (Util.IsNull(source)) return null;
            SHA1Managed sha1 = new SHA1Managed();
            byte[] hashBytes = sha1.ComputeHash(source);
            return hashBytes;
        }

        /// <summary>
        /// Mã hóa theo thuật toán cho trước (1 chuỗi hoặc một mảng byte)
        /// </summary>
        public static string Encypt(string source, string cryptoName)
        {
            if (Util.IsNull(source)) return "";
            byte[] clearBytes = Encoding.Unicode.GetBytes(source);
            HashAlgorithm hash = (HashAlgorithm)CryptoConfig.CreateFromName(cryptoName);
            byte[] hashBytes = hash.ComputeHash(clearBytes);

            return BitConverter.ToString(hashBytes);
        }

        public static byte[] Encrypt(byte[] source, string cryptoName)
        {
            if (Util.IsNull(source)) return null;
            HashAlgorithm hash = (HashAlgorithm)CryptoConfig.CreateFromName(cryptoName);
            byte[] hashBytes = hash.ComputeHash(source);
            return hashBytes;
        }

        #endregion

        #region DATETIME METHODS
        /// <summary>
        /// Kiểm tra xem chuỗi truyền vào có đúng format ngày tháng hay không
        /// </summary>
        public static bool IsDateFormat(string src)
        {
            try
            {
                DateTime.Parse(src);
                return true;
            }
            catch
            {
                return false;
            }
        }

        public static bool IsDateFormat(string src, string format)
        {
            try
            {
                DateTime.ParseExact(src, format, DateTimeFormatInfo.CurrentInfo);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Lấy giá trị ngày tháng cho chuỗi truyền vào
        /// </summary>
        /// <returns></returns>
        public static DateTime ParseDate(string src)
        {
            try
            {
                return DateTime.Parse(src);
            }
            catch
            {
                return DateTime.MinValue;
            }
        }

        public static DateTime ParseDate(string src, string format)
        {
            try
            {
                return DateTime.ParseExact(src, format, DateTimeFormatInfo.CurrentInfo);
            }
            catch
            {
                return DateTime.MinValue;
            }
        }

        /// <summary>
        /// Chuyển một chuỗi có format ngày tháng thành format ngày tháng khác
        /// </summary>
        /// <returns></returns>
        public static string FixDateFormat(string src, string newformat)
        {
            DateTime d = Util.ParseDate(src);
            if (Util.IsNull(d)) return "";
            return d.ToString(newformat);
        }

        public static string FixDateFormat(string src, string newformat, string obldformat)
        {
            DateTime d = Util.ParseDate(src, obldformat);
            if (Util.IsNull(d)) return "";
            return d.ToString(newformat);
        }

        #endregion

        //static public string ConvertSortDirectionToSql(SortDirection sortDirection)
        //{
        //    string newSortDirection = String.Empty;
        //    switch (sortDirection)
        //    {
        //        case SortDirection.Ascending:
        //            newSortDirection = "ASC";
        //            break;
        //        case SortDirection.Descending:
        //            newSortDirection = "DESC";
        //            break;
        //    }
        //    return newSortDirection;
        //}

        //static public string GetSortClause(string sortExpression, SortDirection sortDirection)
        //{
        //    return sortExpression + " " + ConvertSortDirectionToSql(sortDirection);
        //}

        public static String getModuleName(String URIInSys)
        {
            String funcName = "";
            try
            {

                int lenURIInSys = URIInSys.Trim().Length;

                if (URIInSys.IndexOf("?") != -1)
                {
                    if (URIInSys.IndexOf("module") != -1)
                    {
                        if (!URIInSys.Contains("&"))
                        {
                            int lenFunc = lenURIInSys - URIInSys.IndexOf("=") - 1;
                            funcName = URIInSys.Substring(URIInSys.IndexOf("=") + 1, lenFunc);
                        }
                        else
                        {
                            int lenFunc = URIInSys.IndexOf("&") - URIInSys.IndexOf("=") - 1;

                            funcName = URIInSys.Substring(URIInSys.IndexOf("=") + 1, lenFunc);
                        }
                    }
                    else
                    {
                        int lenFunc = URIInSys.IndexOf("?") - 1 - URIInSys.LastIndexOf("/");
                        funcName = URIInSys.Substring(URIInSys.LastIndexOf("/") + 1, lenFunc);
                    }
                }
                else
                {
                    int lenFunc = lenURIInSys - URIInSys.LastIndexOf("/") - 1;
                    funcName = URIInSys.Substring(URIInSys.LastIndexOf("/") + 1, lenFunc);
                }
                return funcName;
            }
            catch (Exception e)
            {
                return "";
                throw e;
            }

        }

        public static int ObjectToInt(object obj)
        {
            try
            {
                return int.Parse(obj.ToString());
            }
            catch
            {
                return 0;
            }
        }

        public static decimal ObjectToDecimal(object obj)
        {
            try
            {
                return decimal.Parse(obj.ToString());
            }
            catch
            {
                return 0;
            }
        }

        public static string DecimalObjectToString(object obj)
        {
            try
            {
                return decimal.Parse(obj.ToString()) > 0 ? decimal.Parse(obj.ToString()).ToString("#,##") : "";
            }
            catch
            {
                return "";
            }
        }

        public static string DecimalObjectToString(object obj, string CurencyCode)
        {
            try
            {
                return decimal.Parse(obj.ToString()) > 0 ? decimal.Parse(obj.ToString()).ToString("#,##") + CurencyCode : "";
            }
            catch
            {
                return "";
            }
        }

        public static string DecimalObjectToString(object obj, bool isVietnameseFormat)
        {
            try
            {
                decimal deci = decimal.Parse(obj.ToString()) - (decimal)((int)decimal.Parse(obj.ToString()));
                int decimals = 0;
                decimals = deci != 0 ? deci.ToString().Remove(0, deci.ToString().LastIndexOf('.') + 1).Length : 0;

                return DecimalObjectToString(obj, isVietnameseFormat, decimals);
            }
            catch
            {
                return "";
            }
        }

        public static string DecimalObjectToStringObject(object obj, bool isVietnameseFormat)
        {
            try
            {
                decimal deci = decimal.Parse(obj.ToString()) - (decimal)((int)decimal.Parse(obj.ToString()));
                int decimals = 0;
                decimals = deci != 0 ? deci.ToString().Remove(0, deci.ToString().LastIndexOf('.') + 1).Length : 0;

                return DecimalObjectToStringObject(obj, isVietnameseFormat, decimals);
            }
            catch
            {
                return "0";
            }
        }

        public static string DecimalObjectToString(object obj, bool isVietnameseFormat, int decimals)
        {
            try
            {
                if (isVietnameseFormat)
                {
                    return decimal.Parse(obj.ToString(), CultureInfo.CreateSpecificCulture("vi-VN")) > 0 ? decimal.Parse(obj.ToString()).ToString("N" + decimals.ToString(), CultureInfo.CreateSpecificCulture("vi-VN")) : "";
                }
                else
                    return decimal.Parse(obj.ToString()) > 0 ? decimal.Parse(obj.ToString()).ToString("N" + decimals.ToString(), CultureInfo.InvariantCulture) : "";
            }
            catch
            {
                return "";
            }
        }

        public static string DecimalObjectToStringObject(object obj, bool isVietnameseFormat, int decimals)
        {
            try
            {
                string str;
                if (isVietnameseFormat)
                {
                    str = decimal.Parse(obj.ToString(), CultureInfo.CreateSpecificCulture("vi-VN")) > 0 ? decimal.Parse(obj.ToString()).ToString("N" + decimals.ToString(), CultureInfo.CreateSpecificCulture("vi-VN")) : "";
                }
                else
                    str = decimal.Parse(obj.ToString()) > 0 ? decimal.Parse(obj.ToString()).ToString("N" + decimals.ToString(), CultureInfo.InvariantCulture) : "";
                return str == "" ? "0" : str;
            }
            catch
            {
                return "0";
            }
        }

        public static string DecimalObjectToString(object obj, string CurencyCode, bool isVietnameseFormat)
        {
            try
            {
                if (isVietnameseFormat)
                    return decimal.Parse(obj.ToString()) > 0 ? decimal.Parse(obj.ToString()).ToString("#,##").Replace(",", ".") + CurencyCode : "";
                else
                    return decimal.Parse(obj.ToString()) > 0 ? decimal.Parse(obj.ToString()).ToString("#,##") + CurencyCode : "";
            }
            catch
            {
                return "";
            }
        }

        public static string ShortString(object obj, int Count, bool extString)
        {
            try
            {
                if (extString)
                    return obj.ToString().Length > Count ? obj.ToString().Substring(0, obj.ToString().Substring(0, Count).ToString().LastIndexOf(" ")) + "..." : obj.ToString();
                else
                    return obj.ToString().Length > Count ? obj.ToString().Substring(0, obj.ToString().Substring(0, Count).ToString().LastIndexOf(" ")) : obj.ToString();
            }
            catch
            {
                return obj.ToString();
            }
        }

        public static string VietNamese2Varchar(object unicodeString)
        {
            return VietNamese2Varchar(unicodeString.ToString());
        }

        public static string VietNamese2Varchar(string unicodeString)
        {
            try
            {
                //Remove VietNamese character
                unicodeString = unicodeString.ToLower();
                unicodeString = unicodeString.Trim();
                unicodeString = Regex.Replace(unicodeString, "[áàảãạâấầẩẫậăắằẳẵặ]", "a");
                unicodeString = Regex.Replace(unicodeString, "[éèẻẽẹêếềểễệ]", "e");
                unicodeString = Regex.Replace(unicodeString, "[iíìỉĩị]", "i");
                unicodeString = Regex.Replace(unicodeString, "[óòỏõọơớờởỡợôốồổỗộ]", "o");
                unicodeString = Regex.Replace(unicodeString, "[úùủũụưứừửữự]", "u");
                unicodeString = Regex.Replace(unicodeString, "[yýỳỷỹỵ]", "y");
                unicodeString = Regex.Replace(unicodeString, "[đ]", "d");

                //Remove special character
                unicodeString = Regex.Replace(unicodeString, "[`'~!@#$%^&*()-+=?>.<,{}[]|]\\:]", "");

                //Remove space
                unicodeString = unicodeString.Replace(" ", "-").Replace(":", "").Replace("/", "-").Replace('"', '-').Replace("\"", "-");
                while (unicodeString.IndexOf("--") >= 0)
                {
                    unicodeString = unicodeString.Replace("--", "-");
                }
                unicodeString = unicodeString[unicodeString.Length - 1] == '-' ? unicodeString.Substring(0, unicodeString.Length - 1) : unicodeString;

                return unicodeString.ToLower();

            }
            catch (Exception)
            {
                return "";
            }
        }
    }
}
